package org.convallaria.system.biz.util;

import org.convallaria.framework.common.constants.sys.DictConstants;
import org.convallaria.system.biz.entity.SysDictData;
import org.convallaria.system.biz.entity.SysDictType;

/**
 * 数据字典工具类
 * 
 * 功能特性：
 * - 提供字典相关的业务逻辑判断方法
 * - 提供字典状态、类型等描述信息
 * - 提供字典数据验证方法
 * - 提供字典信息格式化方法
 * 
 * 设计原则：
 * - 纯静态方法，无状态
 * - 业务逻辑与实体类分离
 * - 便于单元测试
 * - 提高代码可维护性
 * 
 * @author convallaria
 * @since 1.0.0
 */
public class SysDictUtils {

    // ==================== 字典类型状态判断方法 ====================

    /**
     * 判断字典类型是否正常状态
     * 
     * @param dictType 字典类型对象
     * @return true=正常，false=停用
     */
    public static boolean isDictTypeNormal(SysDictType dictType) {
        if (dictType == null || dictType.getStatus() == null) {
            return false;
        }
        return DictConstants.DICT_STATUS_NORMAL.equals(dictType.getStatus());
    }

    /**
     * 判断字典类型是否停用状态
     * 
     * @param dictType 字典类型对象
     * @return true=停用，false=正常
     */
    public static boolean isDictTypeDisabled(SysDictType dictType) {
        if (dictType == null || dictType.getStatus() == null) {
            return false;
        }
        return DictConstants.DICT_STATUS_DISABLED.equals(dictType.getStatus());
    }

    /**
     * 判断字典类型状态是否有效
     * 
     * @param status 状态值
     * @return true=有效，false=无效
     */
    public static boolean isValidDictTypeStatus(String status) {
        return DictConstants.isValidDictStatus(status);
    }

    // ==================== 字典数据状态判断方法 ====================

    /**
     * 判断字典数据是否正常状态
     * 
     * @param dictData 字典数据对象
     * @return true=正常，false=停用
     */
    public static boolean isDictDataNormal(SysDictData dictData) {
        if (dictData == null || dictData.getStatus() == null) {
            return false;
        }
        return DictConstants.DICT_STATUS_NORMAL.equals(dictData.getStatus());
    }

    /**
     * 判断字典数据是否停用状态
     * 
     * @param dictData 字典数据对象
     * @return true=停用，false=正常
     */
    public static boolean isDictDataDisabled(SysDictData dictData) {
        if (dictData == null || dictData.getStatus() == null) {
            return false;
        }
        return DictConstants.DICT_STATUS_DISABLED.equals(dictData.getStatus());
    }

    /**
     * 判断字典数据状态是否有效
     * 
     * @param status 状态值
     * @return true=有效，false=无效
     */
    public static boolean isValidDictDataStatus(String status) {
        return DictConstants.isValidDictStatus(status);
    }

    // ==================== 默认值判断方法 ====================

    /**
     * 判断字典数据是否为默认项
     * 
     * @param dictData 字典数据对象
     * @return true=默认，false=非默认
     */
    public static boolean isDefault(SysDictData dictData) {
        if (dictData == null || dictData.getIsDefault() == null) {
            return false;
        }
        return DictConstants.isDefault(dictData.getIsDefault());
    }

    /**
     * 判断字典数据是否为非默认项
     * 
     * @param dictData 字典数据对象
     * @return true=非默认，false=默认
     */
    public static boolean isNotDefault(SysDictData dictData) {
        if (dictData == null || dictData.getIsDefault() == null) {
            return false;
        }
        return DictConstants.isNotDefault(dictData.getIsDefault());
    }

    /**
     * 判断是否默认值是否有效
     * 
     * @param isDefault 是否默认值
     * @return true=有效，false=无效
     */
    public static boolean isValidIsDefault(String isDefault) {
        return DictConstants.isValidIsDefault(isDefault);
    }

    // ==================== 数据验证方法 ====================

    /**
     * 验证字典类型信息是否完整
     * 
     * @param dictType 字典类型对象
     * @return true=完整，false=不完整
     */
    public static boolean isValidDictType(SysDictType dictType) {
        if (dictType == null) {
            return false;
        }
        
        // 必填字段验证
        if (!DictConstants.isValidDictName(dictType.getDictName())) {
            return false;
        }
        if (!DictConstants.isValidDictType(dictType.getDictType())) {
            return false;
        }
        if (dictType.getTenantId() == null) {
            return false;
        }
        
        // 状态验证
        if (!isValidDictTypeStatus(dictType.getStatus())) {
            return false;
        }
        
        return true;
    }

    /**
     * 验证字典数据信息是否完整
     * 
     * @param dictData 字典数据对象
     * @return true=完整，false=不完整
     */
    public static boolean isValidDictData(SysDictData dictData) {
        if (dictData == null) {
            return false;
        }
        
        // 必填字段验证
        if (!DictConstants.isValidDictLabel(dictData.getDictLabel())) {
            return false;
        }
        if (!DictConstants.isValidDictValue(dictData.getDictValue())) {
            return false;
        }
        if (!DictConstants.isValidDictType(dictData.getDictType())) {
            return false;
        }
        if (dictData.getTenantId() == null) {
            return false;
        }
        
        // 状态验证
        if (!isValidDictDataStatus(dictData.getStatus())) {
            return false;
        }
        
        // 是否默认验证
        if (!isValidIsDefault(dictData.getIsDefault())) {
            return false;
        }
        
        // 排序验证
        if (dictData.getDictSort() != null && !DictConstants.isValidDictSort(dictData.getDictSort())) {
            return false;
        }
        
        // 样式验证
        if (dictData.getCssClass() != null && !DictConstants.isValidCssClass(dictData.getCssClass())) {
            return false;
        }
        if (dictData.getListClass() != null && !DictConstants.isValidListClass(dictData.getListClass())) {
            return false;
        }
        
        return true;
    }

    /**
     * 验证字典名称格式
     * 
     * @param dictName 字典名称
     * @return true=有效，false=无效
     */
    public static boolean isValidDictName(String dictName) {
        return DictConstants.isValidDictName(dictName);
    }

    /**
     * 验证字典类型格式
     * 
     * @param dictType 字典类型
     * @return true=有效，false=无效
     */
    public static boolean isValidDictType(String dictType) {
        return DictConstants.isValidDictType(dictType);
    }

    /**
     * 验证字典标签格式
     * 
     * @param dictLabel 字典标签
     * @return true=有效，false=无效
     */
    public static boolean isValidDictLabel(String dictLabel) {
        return DictConstants.isValidDictLabel(dictLabel);
    }

    /**
     * 验证字典键值格式
     * 
     * @param dictValue 字典键值
     * @return true=有效，false=无效
     */
    public static boolean isValidDictValue(String dictValue) {
        return DictConstants.isValidDictValue(dictValue);
    }

    // ==================== 格式化方法 ====================

    /**
     * 格式化字典类型显示名称
     * 
     * @param dictType 字典类型对象
     * @return 格式化后的显示名称
     */
    public static String formatDictTypeDisplayName(SysDictType dictType) {
        if (dictType == null) {
            return "未知字典类型";
        }
        
        String displayName = dictType.getDictName();
        if (displayName == null || displayName.trim().isEmpty()) {
            displayName = dictType.getDictType();
        }
        
        return displayName != null ? displayName : "未知字典类型";
    }

    /**
     * 格式化字典数据显示名称
     * 
     * @param dictData 字典数据对象
     * @return 格式化后的显示名称
     */
    public static String formatDictDataDisplayName(SysDictData dictData) {
        if (dictData == null) {
            return "未知字典数据";
        }
        
        String displayName = dictData.getDictLabel();
        if (displayName == null || displayName.trim().isEmpty()) {
            displayName = dictData.getDictValue();
        }
        
        return displayName != null ? displayName : "未知字典数据";
    }

    /**
     * 格式化字典类型完整信息
     * 
     * @param dictType 字典类型对象
     * @return 格式化后的完整信息
     */
    public static String formatDictTypeInfo(SysDictType dictType) {
        if (dictType == null) {
            return "字典类型信息为空";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("字典类型ID: ").append(dictType.getDictId()).append(", ");
        sb.append("字典名称: ").append(dictType.getDictName()).append(", ");
        sb.append("字典类型: ").append(dictType.getDictType()).append(", ");
        sb.append("状态: ").append(getDictTypeStatusDesc(dictType.getStatus()));
        
        return sb.toString();
    }

    /**
     * 格式化字典数据完整信息
     * 
     * @param dictData 字典数据对象
     * @return 格式化后的完整信息
     */
    public static String formatDictDataInfo(SysDictData dictData) {
        if (dictData == null) {
            return "字典数据信息为空";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("字典编码: ").append(dictData.getDictCode()).append(", ");
        sb.append("字典标签: ").append(dictData.getDictLabel()).append(", ");
        sb.append("字典键值: ").append(dictData.getDictValue()).append(", ");
        sb.append("字典类型: ").append(dictData.getDictType()).append(", ");
        sb.append("状态: ").append(getDictDataStatusDesc(dictData.getStatus())).append(", ");
        sb.append("是否默认: ").append(getIsDefaultDesc(dictData.getIsDefault()));
        
        return sb.toString();
    }

    // ==================== 描述信息方法 ====================

    /**
     * 获取字典类型状态描述
     * 
     * @param status 状态值
     * @return 状态描述
     */
    public static String getDictTypeStatusDesc(String status) {
        return DictConstants.getDictStatusDesc(status);
    }

    /**
     * 获取字典数据状态描述
     * 
     * @param status 状态值
     * @return 状态描述
     */
    public static String getDictDataStatusDesc(String status) {
        return DictConstants.getDictStatusDesc(status);
    }

    /**
     * 获取是否默认描述
     * 
     * @param isDefault 是否默认值
     * @return 是否默认描述
     */
    public static String getIsDefaultDesc(String isDefault) {
        return DictConstants.getIsDefaultDesc(isDefault);
    }

    // ==================== 业务逻辑方法 ====================

    /**
     * 判断字典类型是否可以删除
     * 
     * @param dictType 字典类型对象
     * @return true=可以删除，false=不能删除
     */
    public static boolean canDeleteDictType(SysDictType dictType) {
        if (dictType == null) {
            return false;
        }
        
        // 停用的字典类型可以删除
        return isDictTypeDisabled(dictType);
    }

    /**
     * 判断字典类型是否可以编辑
     * 
     * @param dictType 字典类型对象
     * @return true=可以编辑，false=不能编辑
     */
    public static boolean canEditDictType(SysDictType dictType) {
        if (dictType == null) {
            return false;
        }
        
        // 正常状态的字典类型可以编辑
        return isDictTypeNormal(dictType);
    }

    /**
     * 判断字典类型是否可以使用
     * 
     * @param dictType 字典类型对象
     * @return true=可以使用，false=不能使用
     */
    public static boolean canUseDictType(SysDictType dictType) {
        if (dictType == null) {
            return false;
        }
        
        // 正常状态的字典类型可以使用
        return isDictTypeNormal(dictType);
    }

    /**
     * 判断字典数据是否可以删除
     * 
     * @param dictData 字典数据对象
     * @return true=可以删除，false=不能删除
     */
    public static boolean canDeleteDictData(SysDictData dictData) {
        if (dictData == null) {
            return false;
        }
        
        // 停用的字典数据可以删除
        return isDictDataDisabled(dictData);
    }

    /**
     * 判断字典数据是否可以编辑
     * 
     * @param dictData 字典数据对象
     * @return true=可以编辑，false=不能编辑
     */
    public static boolean canEditDictData(SysDictData dictData) {
        if (dictData == null) {
            return false;
        }
        
        // 正常状态的字典数据可以编辑
        return isDictDataNormal(dictData);
    }

    /**
     * 判断字典数据是否可以使用
     * 
     * @param dictData 字典数据对象
     * @return true=可以使用，false=不能使用
     */
    public static boolean canUseDictData(SysDictData dictData) {
        if (dictData == null) {
            return false;
        }
        
        // 正常状态的字典数据可以使用
        return isDictDataNormal(dictData);
    }

    /**
     * 判断字典类型是否为空
     * 
     * @param dictType 字典类型对象
     * @return true=为空，false=不为空
     */
    public static boolean isDictTypeEmpty(SysDictType dictType) {
        if (dictType == null) {
            return true;
        }
        
        return (dictType.getDictName() == null || dictType.getDictName().trim().isEmpty()) &&
               (dictType.getDictType() == null || dictType.getDictType().trim().isEmpty());
    }

    /**
     * 判断字典数据是否为空
     * 
     * @param dictData 字典数据对象
     * @return true=为空，false=不为空
     */
    public static boolean isDictDataEmpty(SysDictData dictData) {
        if (dictData == null) {
            return true;
        }
        
        return (dictData.getDictLabel() == null || dictData.getDictLabel().trim().isEmpty()) &&
               (dictData.getDictValue() == null || dictData.getDictValue().trim().isEmpty());
    }

    /**
     * 判断字典类型是否有效（非空且格式正确）
     * 
     * @param dictType 字典类型对象
     * @return true=有效，false=无效
     */
    public static boolean isDictTypeValid(SysDictType dictType) {
        return !isDictTypeEmpty(dictType) && isValidDictType(dictType);
    }

    /**
     * 判断字典数据是否有效（非空且格式正确）
     * 
     * @param dictData 字典数据对象
     * @return true=有效，false=无效
     */
    public static boolean isDictDataValid(SysDictData dictData) {
        return !isDictDataEmpty(dictData) && isValidDictData(dictData);
    }

    /**
     * 比较字典数据排序
     * 
     * @param dictData1 字典数据对象1
     * @param dictData2 字典数据对象2
     * @return 比较结果：负数表示dictData1在前，正数表示dictData2在前，0表示相等
     */
    public static int compareDictDataSort(SysDictData dictData1, SysDictData dictData2) {
        if (dictData1 == null && dictData2 == null) {
            return 0;
        }
        if (dictData1 == null) {
            return 1;
        }
        if (dictData2 == null) {
            return -1;
        }
        
        Integer sort1 = dictData1.getDictSort();
        Integer sort2 = dictData2.getDictSort();
        
        if (sort1 == null && sort2 == null) {
            return 0;
        }
        if (sort1 == null) {
            return 1;
        }
        if (sort2 == null) {
            return -1;
        }
        
        return sort1.compareTo(sort2);
    }

    /**
     * 清理字典类型（转换为小写）
     * 
     * @param dictType 字典类型对象
     * @return 清理后的字典类型
     */
    public static String cleanDictType(SysDictType dictType) {
        if (dictType == null || dictType.getDictType() == null) {
            return "";
        }
        return DictConstants.cleanDictType(dictType.getDictType());
    }

    /**
     * 清理字典标签（去除多余空格）
     * 
     * @param dictData 字典数据对象
     * @return 清理后的字典标签
     */
    public static String cleanDictLabel(SysDictData dictData) {
        if (dictData == null || dictData.getDictLabel() == null) {
            return "";
        }
        return DictConstants.cleanDictLabel(dictData.getDictLabel());
    }

    /**
     * 清理字典键值（转换为小写）
     * 
     * @param dictData 字典数据对象
     * @return 清理后的字典键值
     */
    public static String cleanDictValue(SysDictData dictData) {
        if (dictData == null || dictData.getDictValue() == null) {
            return "";
        }
        return DictConstants.cleanDictValue(dictData.getDictValue());
    }
}
